//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS WorkspacesInstances service.
///
/// Amazon WorkSpaces Instances provides an API framework for managing virtual workspace environments across multiple AWS regions, enabling programmatic creation and configuration of desktop infrastructure.
public struct WorkspacesInstances: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the WorkspacesInstances client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "EUCMIFrontendAPIService",
            serviceName: "WorkspacesInstances",
            serviceIdentifier: "workspaces-instances",
            serviceProtocol: .json(version: "1.0"),
            apiVersion: "2022-07-26",
            endpoint: endpoint,
            errorType: WorkspacesInstancesErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Attaches a volume to a WorkSpace Instance.
    @Sendable
    @inlinable
    public func associateVolume(_ input: AssociateVolumeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateVolumeResponse {
        try await self.client.execute(
            operation: "AssociateVolume", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attaches a volume to a WorkSpace Instance.
    ///
    /// Parameters:
    ///   - device: Device path for volume attachment.
    ///   - volumeId: Volume to be attached.
    ///   - workspaceInstanceId: WorkSpace Instance to attach volume to.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateVolume(
        device: String,
        volumeId: String,
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateVolumeResponse {
        let input = AssociateVolumeRequest(
            device: device, 
            volumeId: volumeId, 
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.associateVolume(input, logger: logger)
    }

    /// Creates a new volume for WorkSpace Instances.
    @Sendable
    @inlinable
    public func createVolume(_ input: CreateVolumeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVolumeResponse {
        try await self.client.execute(
            operation: "CreateVolume", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new volume for WorkSpace Instances.
    ///
    /// Parameters:
    ///   - availabilityZone: Availability zone for the volume.
    ///   - clientToken: Unique token to prevent duplicate volume creation.
    ///   - encrypted: Indicates if the volume should be encrypted.
    ///   - iops: Input/output operations per second for the volume.
    ///   - kmsKeyId: KMS key for volume encryption.
    ///   - sizeInGB: Volume size in gigabytes.
    ///   - snapshotId: Source snapshot for volume creation.
    ///   - tagSpecifications: Metadata tags for the volume.
    ///   - throughput: Volume throughput performance.
    ///   - volumeType: Type of EBS volume.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVolume(
        availabilityZone: String,
        clientToken: String? = CreateVolumeRequest.idempotencyToken(),
        encrypted: Bool? = nil,
        iops: Int? = nil,
        kmsKeyId: String? = nil,
        sizeInGB: Int? = nil,
        snapshotId: String? = nil,
        tagSpecifications: [TagSpecification]? = nil,
        throughput: Int? = nil,
        volumeType: VolumeTypeEnum? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVolumeResponse {
        let input = CreateVolumeRequest(
            availabilityZone: availabilityZone, 
            clientToken: clientToken, 
            encrypted: encrypted, 
            iops: iops, 
            kmsKeyId: kmsKeyId, 
            sizeInGB: sizeInGB, 
            snapshotId: snapshotId, 
            tagSpecifications: tagSpecifications, 
            throughput: throughput, 
            volumeType: volumeType
        )
        return try await self.createVolume(input, logger: logger)
    }

    /// Launches a new WorkSpace Instance with specified configuration parameters, enabling programmatic workspace deployment.
    @Sendable
    @inlinable
    public func createWorkspaceInstance(_ input: CreateWorkspaceInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkspaceInstanceResponse {
        try await self.client.execute(
            operation: "CreateWorkspaceInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Launches a new WorkSpace Instance with specified configuration parameters, enabling programmatic workspace deployment.
    ///
    /// Parameters:
    ///   - clientToken: Unique token to ensure idempotent instance creation, preventing duplicate workspace launches.
    ///   - managedInstance: Comprehensive configuration settings for the WorkSpaces Instance, including network, compute, and storage parameters.
    ///   - tags: Optional metadata tags for categorizing and managing WorkSpaces Instances.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkspaceInstance(
        clientToken: String? = CreateWorkspaceInstanceRequest.idempotencyToken(),
        managedInstance: ManagedInstanceRequest,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkspaceInstanceResponse {
        let input = CreateWorkspaceInstanceRequest(
            clientToken: clientToken, 
            managedInstance: managedInstance, 
            tags: tags
        )
        return try await self.createWorkspaceInstance(input, logger: logger)
    }

    /// Deletes a specified volume.
    @Sendable
    @inlinable
    public func deleteVolume(_ input: DeleteVolumeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVolumeResponse {
        try await self.client.execute(
            operation: "DeleteVolume", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified volume.
    ///
    /// Parameters:
    ///   - volumeId: Identifier of the volume to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVolume(
        volumeId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVolumeResponse {
        let input = DeleteVolumeRequest(
            volumeId: volumeId
        )
        return try await self.deleteVolume(input, logger: logger)
    }

    /// Deletes the specified WorkSpace
    @Sendable
    @inlinable
    public func deleteWorkspaceInstance(_ input: DeleteWorkspaceInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWorkspaceInstanceResponse {
        try await self.client.execute(
            operation: "DeleteWorkspaceInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified WorkSpace
    ///
    /// Parameters:
    ///   - workspaceInstanceId: Unique identifier of the WorkSpaces Instance targeted for deletion.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkspaceInstance(
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWorkspaceInstanceResponse {
        let input = DeleteWorkspaceInstanceRequest(
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.deleteWorkspaceInstance(input, logger: logger)
    }

    /// Detaches a volume from a WorkSpace Instance.
    @Sendable
    @inlinable
    public func disassociateVolume(_ input: DisassociateVolumeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateVolumeResponse {
        try await self.client.execute(
            operation: "DisassociateVolume", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Detaches a volume from a WorkSpace Instance.
    ///
    /// Parameters:
    ///   - device: Device path of volume to detach.
    ///   - disassociateMode: Mode for volume detachment.
    ///   - volumeId: Volume to be detached.
    ///   - workspaceInstanceId: WorkSpace Instance to detach volume from.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateVolume(
        device: String? = nil,
        disassociateMode: DisassociateModeEnum? = nil,
        volumeId: String,
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateVolumeResponse {
        let input = DisassociateVolumeRequest(
            device: device, 
            disassociateMode: disassociateMode, 
            volumeId: volumeId, 
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.disassociateVolume(input, logger: logger)
    }

    /// Retrieves detailed information about a specific WorkSpace Instance.
    @Sendable
    @inlinable
    public func getWorkspaceInstance(_ input: GetWorkspaceInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkspaceInstanceResponse {
        try await self.client.execute(
            operation: "GetWorkspaceInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves detailed information about a specific WorkSpace Instance.
    ///
    /// Parameters:
    ///   - workspaceInstanceId: Unique identifier of the WorkSpace Instance to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkspaceInstance(
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkspaceInstanceResponse {
        let input = GetWorkspaceInstanceRequest(
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.getWorkspaceInstance(input, logger: logger)
    }

    /// Retrieves a list of instance types supported by Amazon WorkSpaces Instances, enabling precise workspace infrastructure configuration.
    @Sendable
    @inlinable
    public func listInstanceTypes(_ input: ListInstanceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInstanceTypesResponse {
        try await self.client.execute(
            operation: "ListInstanceTypes", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of instance types supported by Amazon WorkSpaces Instances, enabling precise workspace infrastructure configuration.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of instance types to return in a single API call. Enables pagination of instance type results.
    ///   - nextToken: Pagination token for retrieving subsequent pages of instance type results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listInstanceTypes(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInstanceTypesResponse {
        let input = ListInstanceTypesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInstanceTypes(input, logger: logger)
    }

    /// Retrieves a list of AWS regions supported by Amazon WorkSpaces Instances, enabling region discovery for workspace deployments.
    @Sendable
    @inlinable
    public func listRegions(_ input: ListRegionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRegionsResponse {
        try await self.client.execute(
            operation: "ListRegions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of AWS regions supported by Amazon WorkSpaces Instances, enabling region discovery for workspace deployments.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of regions to return in a single API call. Enables pagination of region results.
    ///   - nextToken: Pagination token for retrieving subsequent pages of region results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRegions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRegionsResponse {
        let input = ListRegionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listRegions(input, logger: logger)
    }

    /// Retrieves tags for a WorkSpace Instance.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves tags for a WorkSpace Instance.
    ///
    /// Parameters:
    ///   - workspaceInstanceId: Unique identifier of the WorkSpace Instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Retrieves a collection of WorkSpaces Instances based on specified filters.
    @Sendable
    @inlinable
    public func listWorkspaceInstances(_ input: ListWorkspaceInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkspaceInstancesResponse {
        try await self.client.execute(
            operation: "ListWorkspaceInstances", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a collection of WorkSpaces Instances based on specified filters.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of WorkSpaces Instances to return in a single response.
    ///   - nextToken: Pagination token for retrieving subsequent pages of WorkSpaces Instances.
    ///   - provisionStates: Filter WorkSpaces Instances by their current provisioning states.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkspaceInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        provisionStates: [ProvisionStateEnum]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkspaceInstancesResponse {
        let input = ListWorkspaceInstancesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            provisionStates: provisionStates
        )
        return try await self.listWorkspaceInstances(input, logger: logger)
    }

    /// Adds tags to a WorkSpace Instance.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds tags to a WorkSpace Instance.
    ///
    /// Parameters:
    ///   - tags: Tags to be added to the WorkSpace Instance.
    ///   - workspaceInstanceId: Unique identifier of the WorkSpace Instance to tag.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        tags: [Tag],
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            tags: tags, 
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from a WorkSpace Instance.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from a WorkSpace Instance.
    ///
    /// Parameters:
    ///   - tagKeys: Keys of tags to be removed.
    ///   - workspaceInstanceId: Unique identifier of the WorkSpace Instance to untag.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        tagKeys: [String],
        workspaceInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            tagKeys: tagKeys, 
            workspaceInstanceId: workspaceInstanceId
        )
        return try await self.untagResource(input, logger: logger)
    }
}

extension WorkspacesInstances {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: WorkspacesInstances, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension WorkspacesInstances {
    /// Return PaginatorSequence for operation ``listInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceTypesPaginator(
        _ input: ListInstanceTypesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInstanceTypesRequest, ListInstanceTypesResponse> {
        return .init(
            input: input,
            command: self.listInstanceTypes,
            inputKey: \ListInstanceTypesRequest.nextToken,
            outputKey: \ListInstanceTypesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of instance types to return in a single API call. Enables pagination of instance type results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceTypesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInstanceTypesRequest, ListInstanceTypesResponse> {
        let input = ListInstanceTypesRequest(
            maxResults: maxResults
        )
        return self.listInstanceTypesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRegions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRegionsPaginator(
        _ input: ListRegionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRegionsRequest, ListRegionsResponse> {
        return .init(
            input: input,
            command: self.listRegions,
            inputKey: \ListRegionsRequest.nextToken,
            outputKey: \ListRegionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRegions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of regions to return in a single API call. Enables pagination of region results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRegionsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRegionsRequest, ListRegionsResponse> {
        let input = ListRegionsRequest(
            maxResults: maxResults
        )
        return self.listRegionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkspaceInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkspaceInstancesPaginator(
        _ input: ListWorkspaceInstancesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkspaceInstancesRequest, ListWorkspaceInstancesResponse> {
        return .init(
            input: input,
            command: self.listWorkspaceInstances,
            inputKey: \ListWorkspaceInstancesRequest.nextToken,
            outputKey: \ListWorkspaceInstancesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkspaceInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of WorkSpaces Instances to return in a single response.
    ///   - provisionStates: Filter WorkSpaces Instances by their current provisioning states.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkspaceInstancesPaginator(
        maxResults: Int? = nil,
        provisionStates: [ProvisionStateEnum]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkspaceInstancesRequest, ListWorkspaceInstancesResponse> {
        let input = ListWorkspaceInstancesRequest(
            maxResults: maxResults, 
            provisionStates: provisionStates
        )
        return self.listWorkspaceInstancesPaginator(input, logger: logger)
    }
}

extension WorkspacesInstances.ListInstanceTypesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkspacesInstances.ListInstanceTypesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkspacesInstances.ListRegionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkspacesInstances.ListRegionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkspacesInstances.ListWorkspaceInstancesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkspacesInstances.ListWorkspaceInstancesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            provisionStates: self.provisionStates
        )
    }
}
